var _excluded = ['treeData', 'className', 'value', 'multiple', 'fieldNames'];
function _extends() {
  _extends = Object.assign
    ? Object.assign.bind()
    : function (target) {
        for (var i = 1; i < arguments.length; i++) {
          var source = arguments[i];
          for (var key in source) {
            if (Object.prototype.hasOwnProperty.call(source, key)) {
              target[key] = source[key];
            }
          }
        }
        return target;
      };
  return _extends.apply(this, arguments);
}
function _slicedToArray(arr, i) {
  return (
    _arrayWithHoles(arr) ||
    _iterableToArrayLimit(arr, i) ||
    _unsupportedIterableToArray(arr, i) ||
    _nonIterableRest()
  );
}
function _nonIterableRest() {
  throw new TypeError(
    'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
  );
}
function _unsupportedIterableToArray(o, minLen) {
  if (!o) return;
  if (typeof o === 'string') return _arrayLikeToArray(o, minLen);
  var n = Object.prototype.toString.call(o).slice(8, -1);
  if (n === 'Object' && o.constructor) n = o.constructor.name;
  if (n === 'Map' || n === 'Set') return Array.from(o);
  if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
    return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length;
  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
  return arr2;
}
function _iterableToArrayLimit(arr, i) {
  var _i =
    null == arr
      ? null
      : ('undefined' != typeof Symbol && arr[Symbol.iterator]) || arr['@@iterator'];
  if (null != _i) {
    var _s,
      _e,
      _x,
      _r,
      _arr = [],
      _n = !0,
      _d = !1;
    try {
      if (((_x = (_i = _i.call(arr)).next), 0 === i)) {
        if (Object(_i) !== _i) return;
        _n = !1;
      } else
        for (
          ;
          !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i);
          _n = !0
        );
    } catch (err) {
      (_d = !0), (_e = err);
    } finally {
      try {
        if (!_n && null != _i.return && ((_r = _i.return()), Object(_r) !== _r)) return;
      } finally {
        if (_d) throw _e;
      }
    }
    return _arr;
  }
}
function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}
function _objectWithoutProperties(source, excluded) {
  if (source == null) return {};
  var target = _objectWithoutPropertiesLoose(source, excluded);
  var key, i;
  if (Object.getOwnPropertySymbols) {
    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
    for (i = 0; i < sourceSymbolKeys.length; i++) {
      key = sourceSymbolKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
      target[key] = source[key];
    }
  }
  return target;
}
function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;
  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }
  return target;
}
import { useTree } from '@szzj/hooks';
import { TreeSelect as AntdTreeSelect } from 'antd';
import 'antd/es/tree-select/style/index.js';
import classnames from 'classnames';
import React, { forwardRef, useEffect, useState } from 'react';
import { useFieldContext } from '../_utils/contexts/FieldContext';
import createField from '../createField';
import useRequestOptions from './hooks/useRequestOptions';
/**
 * 下拉框
 */
var TreeSelect = /*#__PURE__*/ forwardRef(function (_ref, ref) {
  var treeDataOrRequest = _ref.treeData,
    className = _ref.className,
    value = _ref.value,
    _ref$multiple = _ref.multiple,
    multiple = _ref$multiple === void 0 ? false : _ref$multiple,
    fieldNames = _ref.fieldNames,
    rest = _objectWithoutProperties(_ref, _excluded);
  var _ref2 = fieldNames || {},
    _ref2$value = _ref2.value,
    valueKey = _ref2$value === void 0 ? 'value' : _ref2$value,
    _ref2$children = _ref2.children,
    childrenKey = _ref2$children === void 0 ? 'children' : _ref2$children,
    _ref2$label = _ref2.label,
    labelKey = _ref2$label === void 0 ? 'title' : _ref2$label;
  var _useFieldContext = useFieldContext(),
    label = _useFieldContext.label;
  var _useRequestOptions = useRequestOptions(treeDataOrRequest),
    treeData = _useRequestOptions.treeData,
    queryTreeData = _useRequestOptions.queryTreeData,
    cancelQuery = _useRequestOptions.cancelQuery;
  var _useState = useState([]),
    _useState2 = _slicedToArray(_useState, 2),
    expandedKeys = _useState2[0],
    setExpandedKeys = _useState2[1];

  /**
   * 树控制器
   */
  var _useTree = useTree(treeData, {
      uniqueKey: valueKey,
      childrenKey: childrenKey,
    }),
    findAncestorNodes = _useTree.findAncestorNodes,
    treeNodes = _useTree.treeNodes;

  /**
   * 有初始value时，展开选中节点
   * 没有初始value时，展开一级节点
   */
  useEffect(
    function () {
      if (value && treeNodes.length && !multiple) {
        setExpandedKeys(
          findAncestorNodes(value).map(function (item) {
            return item[valueKey];
          }),
        );
      } else if (treeNodes.length) {
        setExpandedKeys(
          treeNodes.map(function (node) {
            return node[valueKey];
          }),
        );
      }
    },
    [treeNodes.length, value],
  );
  return /*#__PURE__*/ React.createElement(
    AntdTreeSelect,
    _extends(
      {
        placeholder: '\u8BF7\u9009\u62E9'.concat(label),
        className: classnames('szzj-tree-select', className),
        ref: ref,
        treeData: treeData,
        treeExpandedKeys: expandedKeys,
        onTreeExpand: function onTreeExpand(keys) {
          return setExpandedKeys(keys);
        },
        value: value,
        multiple: multiple,
        treeNodeFilterProp: labelKey,
      },
      rest,
      {
        fieldNames: fieldNames,
      },
    ),
  );
});
export default createField(TreeSelect);
